import http from "@/util/request";
import { queryUrl } from "@/util/config";

/**
 * 安全解码UTF-8数据
 * @param {ArrayBuffer} data - 二进制数据
 * @returns {string} - 解码后的文本
 */
function safeDecodeUTF8(data) {
    try {
        // 检查TextDecoder是否可用
        if (typeof TextDecoder !== 'undefined') {
            return new TextDecoder('utf-8').decode(data);
        } else {
            // TextDecoder不可用时，使用兼容的UTF-8解码方法
            return decodeUTF8Manually(new Uint8Array(data));
        }
    } catch (e) {
        console.error('UTF-8解码失败:', e);
        // 如果失败，尝试使用兼容方式
        try {
            return decodeUTF8Manually(new Uint8Array(data));
        } catch (e2) {
            console.error('备用解码也失败:', e2);
            return '';
        }
    }
}

/**
 * 手动解码UTF-8数据（兼容TextDecoder不可用的环境）
 * @param {Uint8Array} bytes - 字节数组
 * @returns {string} - 解码后的文本
 */
function decodeUTF8Manually(bytes) {
    let result = '';
    let i = 0;
    
    while (i < bytes.length) {
        let byte = bytes[i];
        
        // 单字节字符 (0xxxxxxx)
        if (byte < 0x80) {
            result += String.fromCharCode(byte);
            i++;
        }
        // 双字节字符 (110xxxxx 10xxxxxx)
        else if (byte >= 0xC0 && byte < 0xE0) {
            if (i + 1 < bytes.length) {
                let byte2 = bytes[i + 1];
                if ((byte2 & 0xC0) === 0x80) {
                    let codePoint = ((byte & 0x1F) << 6) | (byte2 & 0x3F);
                    result += String.fromCodePoint(codePoint);
                    i += 2;
                } else {
                    // 无效的UTF-8序列，跳过
                    i++;
                }
            } else {
                // 数据不完整，跳过
                i++;
            }
        }
        // 三字节字符 (1110xxxx 10xxxxxx 10xxxxxx)
        else if (byte >= 0xE0 && byte < 0xF0) {
            if (i + 2 < bytes.length) {
                let byte2 = bytes[i + 1];
                let byte3 = bytes[i + 2];
                if ((byte2 & 0xC0) === 0x80 && (byte3 & 0xC0) === 0x80) {
                    let codePoint = ((byte & 0x0F) << 12) | ((byte2 & 0x3F) << 6) | (byte3 & 0x3F);
                    result += String.fromCodePoint(codePoint);
                    i += 3;
                } else {
                    // 无效的UTF-8序列，跳过
                    i++;
                }
            } else {
                // 数据不完整，跳过
                i++;
            }
        }
        // 四字节字符 (11110xxx 10xxxxxx 10xxxxxx 10xxxxxx)
        else if (byte >= 0xF0 && byte < 0xF8) {
            if (i + 3 < bytes.length) {
                let byte2 = bytes[i + 1];
                let byte3 = bytes[i + 2];
                let byte4 = bytes[i + 3];
                if ((byte2 & 0xC0) === 0x80 && (byte3 & 0xC0) === 0x80 && (byte4 & 0xC0) === 0x80) {
                    let codePoint = ((byte & 0x07) << 18) | ((byte2 & 0x3F) << 12) | ((byte3 & 0x3F) << 6) | (byte4 & 0x3F);
                    result += String.fromCodePoint(codePoint);
                    i += 4;
                } else {
                    // 无效的UTF-8序列，跳过
                    i++;
                }
            } else {
                // 数据不完整，跳过
                i++;
            }
        }
        // 无效字节，跳过
        else {
            i++;
        }
    }
    
    return result;
}
/**
 * AI生成需求描述（流式响应）
 * @param {Object} data - 请求参数
 * @param {String} data.projectName - 项目标题
 * @param {String} data.categoryCode - 类目代码
 * @param {Function} onData - 数据流回调函数
 * @param {Function} onError - 错误回调函数
 * @param {Function} onComplete - 完成回调函数
 * @returns {Object} - 返回包含abort方法的控制器对象
 */
export function generateRequirementsStream(data, onData, onError, onComplete) {
    const { projectName, categoryCode } = data;
    let buffer = ''; // 用于拼接不完整的数据块

    // 构建URL，与generateRequirementsSync保持一致
    const url = `${queryUrl}/ai/agent/generate-requirements?projectName=${encodeURIComponent(projectName)}&categoryCode=${encodeURIComponent(categoryCode)}`;

    console.log('请求URL:', url);

    // 处理接收到的数据块
    function processChunk(chunk) {
        if (!chunk.data) return;

        // 解码数据
        const text = safeDecodeUTF8(chunk.data);
        console.log('解码后的数据:', text);

        // 将新数据添加到缓冲区
        buffer += text;

        // 在整个缓冲区中查找并提取所有 data: 段
        let searchIndex = 0;
        while (true) {
            // 查找下一个 data: 的位置
            const dataIndex = buffer.indexOf('data:', searchIndex);
            if (dataIndex === -1) {
                // 没有找到更多的 data:，保留剩余内容到缓冲区
                buffer = buffer.substring(searchIndex);
                break;
            }

            // 找到 data: 的位置，提取其后的内容
            const afterDataStart = dataIndex + 5; // 'data:' 长度为5

            // 查找下一个 data: 的位置
            const nextDataIndex = buffer.indexOf('data:', afterDataStart);
            let content;
            let nextSearchIndex;

            if (nextDataIndex !== -1) {
                // 如果找到下一个 data:，只提取到下一个 data: 之前的内容
                content = buffer.substring(afterDataStart, nextDataIndex);
                nextSearchIndex = nextDataIndex;
            } else {
                // 如果没有找到下一个 data:，检查是否有完整的消息结束标志
                // 查找可能的消息结束位置（通常是 \n\n）
                if (buffer.length > afterDataStart) {
                    content = buffer.substring(afterDataStart);
                    nextSearchIndex = buffer.length;
                    buffer = ''; // 清空缓冲区
                } else {
                    // 没有找到消息结束，说明数据可能不完整，保留到缓冲区
                    buffer = buffer.substring(dataIndex);
                    break;
                }
            }

            try {
                // 清理内容并传递给回调函数
                let cleanContent = content.trim();
                
                // 记录提取后的内容用于调试
                console.log('提取后的内容:', cleanContent);
                
                // 传递清理后的内容
                if (cleanContent) {
                    onData && onData(cleanContent);
                }
            } catch (e) {
                console.error('处理SSE消息失败:', e);
            }

            searchIndex = nextSearchIndex;
        }
    }

    // 创建请求任务，以便后续可以取消
    let requestTask = uni.request({
        url: url,
        method: 'POST',
        enableChunked: true, // 启用分块传输
        responseType: 'arraybuffer', // 使用arraybuffer接收二进制数据
        header: {
            'Authorization': 'Bearer ' + uni.getStorageSync('token'),
            'Accept': 'text/event-stream', // SSE格式
            'Content-Type': 'application/json',
            'x-source': 'wx'
        },
        data: {}, // 不在data中传参，使用URL参数
        success: (res) => {
            console.log('请求成功，状态码:', res.statusCode);
            if (res.statusCode !== 200) {
                console.error('请求失败，状态码:', res.statusCode);
                onError && onError(new Error(`请求失败：${res.statusCode}`));
            }
        },
        fail: (err) => {
            console.error('请求失败:', err);
            if (err.errMsg !== 'request:fail abort') {
                onError && onError(err);
            }
        },
        complete: () => {
            // 确保请求结束时调用完成回调
            console.log('请求完成');
            onComplete && onComplete();

            // 注销事件监听
            if (requestTask) {
                if (requestTask.offHeadersReceived) {
                    requestTask.offHeadersReceived();
                }
                if (requestTask.offChunkReceived) {
                    requestTask.offChunkReceived();
                }
            }
        }
    });

    // 注册数据块接收事件
    if (requestTask.onChunkReceived) {
        requestTask.onChunkReceived(processChunk);
    } else {
        console.warn('当前环境不支持onChunkReceived，将无法实现流式输出');
        // 尝试使用wx.request
        try {
            const wxRequestTask = wx.request({
                url: url,
                method: 'POST',
                enableChunked: true,
                responseType: 'arraybuffer',
                header: {
                    'Authorization': 'Bearer ' + uni.getStorageSync('token'),
                    'Accept': 'text/event-stream',
                    'Content-Type': 'application/json',
                    'x-source': 'wx'
                },
                success: requestTask.success,
                fail: requestTask.fail,
                complete: requestTask.complete
            });

            if (wxRequestTask && wxRequestTask.onChunkReceived) {
                wxRequestTask.onChunkReceived(processChunk);

                // 更新requestTask以便能够中止请求
                requestTask = wxRequestTask;
            }
        } catch (e) {
            console.error('尝试使用wx.request失败:', e);
        }
    }

    // 返回控制器对象
    return {
        abort: () => {
            if (requestTask && typeof requestTask.abort === 'function') {
                requestTask.abort();
            }
        }
    };
}


/**
 * AI推荐价格
 * @param {Object} data - 请求参数
 * @param {String} data.projectName - 项目标题
 * @param {String} data.categoryCode - 类目代码  
 * @param {String} data.description - 需求描述
 * @returns {Promise} - 返回价格推荐结果
 */

export function recommendPriceSync(data) {
    const url = `/ai/agent/generate-price-sync`;
    return http(url, data, true, 'POST');
} 